Magnum One

home *** CD-ROM | disk | FTP | other *** search

/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / asmbler.arc / NFIND.ASM < prev next >

Wrap

Assembly Source File | 1988-11-20 | 37.2 KB | 878 lines

COMMENT & XFIND Filter Command ------------------------------------------------------------------------- Purpose: This filter sends to the standard output device all lines from the filenames specified in the command line that contain the specified string. Letter case is IGNORED in the comparisons, unless an exact match is requested by the /E switch. Command line parameters may be separated by one or more blanks, tabs, or commas. Format: XFIND [/C] [/E] [/N] [/V] "pat" [[d:][path]filename[.ext]...] Type: Internal External *** Remarks: The search is restricted to strings found in a single lines. Patterns split across line boundaries will not be recognized. The /C parameter causes XFIND to display only a count of the number of matching occurrences of string in each file, without displaying the matching lines from the file. The /E parameter requests an exact match with respect to letter case in the string. The /N parameter causes the relative line number of each matching line to be displayed ahead of the line from the file. The /V parameter causes all lines NOT containing the string to be displayed. The string must be enclosed in double quotes. Two quotes in succession are taken as a single quote. Unlike FIND, global filename characters ARE allowed in the filenames or extensions, but alas, due to DOS 2.0 limitations, not in directory paths. Examples: XFIND /C "equ" *.asm ! Count the number of equ's XFIND "foobar" *.for,*.asm,*.pas xfind /e "Tel:" phone1 phone2 ph*.txt phone3 Error returns: 0 - success 1 - empty pattern 2 - command line incomplete 3 - one or more file open failures (some output may be produced) 4 - file not found in wildcard expansion 5 - file read error ------------------------------------------------------------------------- The code has been developed from a disassembly of the IBM PC FIND Filter command. The 8088 has single instructions for scanning a string for an exact match or mismatch with a single character, but none for doing this with translation. Using translation turns one of these instructions into a 5-instruction loop with 5 entry/exit instructions, and the other becomes a 9-instruction loop with 4 entry/exit instructions. A test in a large file directory showed this routine to be about 15% slower than the FIND utility (87 sec vs 77 sec), which is not an unacceptable overhead. [03-Feb-84] Nelson H.F. Beebe, University of Utah [01-Mar-84] Brad Davis, Drafting Services Ltd, Salt Lake City, UT (changed code to allow use as .COM file and have big input buffer) & include ascii.inc include dos.inc MAXBUF equ 58*1024 ; Buffer size - freely variable within ; segment size limitation. Original value ; was 4096. Code takes 3K, leave 3K for stack assume cs:findc,ds:findc,es:findc,ss:findc findc segment para public 'code' org 100H ; where a .COM file begins start: jmp find ; jump around constant data db "MAUlloa/Microsoft/V126" colon db ':',' ' ; 16 linstr db '[' ; 18 intstr db 8 dup (0) ; 19 ; Flags recording switch settings. These should be consecutive bytes. ; A value FLAGSET means the flag is set, any other means not set FLAGSET equ -1 ; value signalling flag set flags equ $ ; symbol used to index table notflg db 0 ; /V cntflg db 0 ; /C numflg db 0 ; /N exactflg db 0 ; /E ; return code flags in order of increasing severity. The highest ; met is returned RC_OKAY equ 0 ; success RC_PATT equ 1 ; empty pattern RC_PARM equ 2 ; bad command line syntax RC_FILE equ 3 ; file open failure RC_NFND equ 4 ; file not found RC_READ equ 5 ; file read error rc db RC_OKAY ; return code db 0,0 ; 24,25 matches dw ; 26 lineno dw ; 28 find: ; Begin main program mov rc,RC_OKAY ; tentative return code mov ah,$DOS_GETVERSION int $DOS cmp al,2 ; version 2 or later? jge cont ; jump if yes mov dx,offset baddos mov ah,$DOS_STROUT ; print string int $DOS xor ax,ax ; clear ax mov ah,$DOS_EXIT int $DOS assume cs:findc,ds:findc cont: ; continue main program now that DOS mov si,81h ; Address in PSP of command line call skipsp ; Skip leading spaces or bx,bx ; Test skip result, non-zero at CR jz haveparam ; jump if have command line data cnterr: mov dx,offset numerr; error - need more parameters mov cl,numlen ; message and message length in dx,cl call writedserr ; write a message mov al,RC_PARM ; return code call setrc jmp errexit ; abort haveparam: mov ah,$DOS_SWITCH ; get switchar (undocument internal call) mov al,$DOS_SWITCH_GET int $DOS push dx ; save switch character scanswitch: ; begin loop to scan for switches lodsb ; get byte from [si] to al, increment si cmp al,' ' ; blank? je moresp ; jump if so to flush more space cmp al,.HT ; tab? je moresp ; jump if so to flush more space cmp al,.CR ; end-of-line? je cnterr ; jump if so -- error - need more data pop dx ; restore switch character cmp al,dl ; switch character? jne scanpat ; jump if not - now expect to find "pattern" push dx ; save switch character again lodsb ; get byte from [si] to al, increment si cmp al,' ' ; blank? je moresp ; jump if so to flush more space cmp al,.HT ; tab? je moresp ; jump if so to flush more space cmp al,.CR ; end-of-line? je cnterr ; jump if so -- error - need more data call lcuc ; convert to upper-case mov bx,offset notflg cmp al,'C' ; /C? (count matching lines only) je setcnt ; jump if yes cmp al,'E' ; /E? (exact match) je setexact ; jump if yes cmp al,'N' ; /N? (line numbers) je setnum ; jump if yes cmp al,'V' ; /V? (invert search) je setnot ; jump if yes mov pattrn[0],al ; unrecognized switch character mov dx,offset prmerr; message mov cl,prmlen ; and length call writedserr ; go write it mov dx,offset pattrn; NUL mov cx,1 ; 1 character call writedserr ; write the NUL mov dx,offset crlf ; and a CR LF mov cx,2 call writedserr jmp scanswitch ; continue switch scan setcnt: ; /C found mov di,cntflg-flags ; offset in switch table jmp short setflg ; go set it setexact: mov di,exactflg-flags ; offset in switch table jmp short setflg ; go set it setnum: ; /N found mov di,numflg-flags ; offset in switch table jmp short setflg ; go set it setnot: ; /V found mov di,notflg-flags ; offset in switch table ; fall through to setflg setflg: ; set the switch mov byte ptr [bx+di],FLAGSET jmp scanswitch ; continue switch scan moresp: ; flush white space in command line dec si ; backup to space just found call skipsp ; go skip some space or bx,bx ; end-of-line reached? jz scanswitch ; jump if not jmp cnterr ; error - expected more data scanpat: ; Begin code to scan "pattern" cmp al,'"' ; Quote? jne nopat ; Jump if not - error if no pattern mov di,offset pattrn; where to store the pattern xor cx,cx ; clear count of pattern length patch: lodsb ; get byte from [si] to al, increment si cmp al,.CR ; end-of-line? jne stlpat ; jump if not, still in pattern nopat: ; here if pattern absent or incomplete mov dx,offset synerr; message mov cl,synlen ; and length call writedserr ; write it mov al,RC_PATT ; return code call setrc jmp errexit ; abort stlpat: ; here if still in pattern cmp al,'"' ; quote? jne stoch ; jump if not to save character lodsb ; get byte from [si] to al, increment si cmp al,'"' ; pair of quotes? je stoch ; yes, save only one of them dec si ; no, must be end of pattern mov patlen,cx ; save pattern length or cx,cx ; was it zero? jnz havpat ; jump if not, have valid pattern mov al,RC_PATT ; return code for empty pattern call setrc jmp errexit ; abort stoch: ; store pattern character stosb ; store byte in al at [di], increment di inc cx ; count the character jmp patch ; go back for more havpat: call skipsp ; flush more white space or bx,bx ; end-of-line yet? jz havfil ; no, expect filename(s) now mov ax,$STDIN ; no file names, so use standard input jmp doread ; go begin the read of the file havfil: ; Begin scan for filename(s) call clrcnt ; go zero some counts mov di,offset filnam; where to store the filename xor cx,cx ; clear the filename length count filch: ; loop to collect the next filename lodsb ; get byte from [si] to al, increment si cmp al,' ' ; blank? je filend ; jump if so, have a filename cmp al,.HT ; tab? je filend ; jump if so, have a filename cmp al,.COMMA ; comma? je filend ; jump if so, have a filename cmp al,.CR ; end-of-line? je filend ; jump if so, have a filename stosb ; must be filename character, save it inc cx ; and count it jmp filch ; loop back for more filend: ; here when filename collected dec si ; backup to terminator character after name mov byte ptr [di],.NUL ; replace terminator by NUL push si ; save registers so we can scan for the mov fillen,cx ; save name length mov dx,offset fildta mov ah,$DOS_SETDTA int $DOS ; set new disk transfer area mov cx,0 ; attribute flags - find only normal files mov dx,offset filnam ; address of wild-carded filename mov ah,$DOS_FINDFIRST int $DOS ; find first matching file jmp short file00 ; go check error return filenext: ; here to find next matching file mov ah,$DOS_FINDNEXT int $DOS ; find next matching file file00: ; here to check error return of FINDFIRST ; or FINDNEXT jnb filmak ; jump if carry not set ; find file failed -- test error code returned in ax file01: cmp ax,18 ; no more files? jne file02 ; jump if not "no more files" condition jmp nxtfil ; no more files from this expansion file02: cmp ax,2 ; file not found? jne file03 ; jump if other error mov al,RC_NFND ; "file not found" error call setrc jmp nxtfil file03: ; some other undocumented error mov al,RC_FILE call setrc jmp nxtfil filmak: ; here after matching file found call makefile ; go attach path to name mov dx,offset fpath ; address of the full filename mov ah,$DOS_OPEN2 mov al,$DOS_OPEN2_READ int $DOS ; open the file for input jnb filopn ; jump if carry not set, open okay jmp badfil ; carry set, open failed filopn: ; here after file opened (ax=handle) push ax ; save file handle mov dx,offset seplin; address of separator line mov cl,seplen ; and its length xor ch,ch ; clear top half of cx call writestr ; write separator line mov dx,offset fpath ; address of filename mov cx,fpalen ; and its length call writestr ; append filename to separator line cmp cntflg,FLAGSET ; was /C specified? je nocrlf ; jump if yes - will only write count mov dx,offset crlf ; else output CR LF mov cx,2 call writestr nocrlf: pop ax ; restore file handle doread: ; here to read the open file mov bx,ax ; file handle nxtread: ; here for next block of file mov dx,offset buffer; where to put block mov cx,MAXBUF ; how long it is mov ah,$DOS_READ2 int $DOS ; read the block jnb didread ; jump if carry not set, read okay jmp badread ; carry set on error didread: or ax,ax ; test count of bytes read jnz grepbuf ; if non-zero, go do pattern match cmp cntflg,FLAGSET ; end-of-file, was /C specified? jne nocnt ; no, all done on this file call writecnt ; yes, write the count of matches nocnt: cmp bx,$STDIN ; input from standard input file? jne doclose ; jump if not and close the file jmp nrmexit ; yes, no need to close, and all done doclose: ; here to close the file (handle in bx) mov ah,$DOS_CLOSE2 int $DOS ; close the file jmp filenext ; and go for next one in wild list grepbuf: ; here to search block for pattern push bx ; save file handle mov bp,offset buffer; where the block is mov di,ax ; count of bytes in block cmp ax,MAXBUF ; block full? jge nopatch ; jump if yes mov bx,bp ; partial block, get address of block cmp byte ptr [bx+di-01],.LF ; is last character LF? je nopatch ; yes mov byte ptr [bx+di],.CR ; no, append CR LF at end of file inc di ; when it is missing, since mov byte ptr [bx+di],.LF ; the search algorithm expects this inc di ; terminator nopatch: push di ; save count of bytes in block push bp ; save block address mov dx,patlen ; pattern length dec dx ; pattern length - 1 nxtscn: inc lineno ; increment line number pop bp ; block address mov di,bp pop cx ; count of bytes in block mov bx,cx mov al,.LF jcxz nofulln ; jump if no more bytes in block repnz scasb ; search for LF marking end-of-line jne nofulln ; jump if no end-of-line in block push cx ; save count of bytes remaining push di ; and location of end-of-line mov cx,di ; where LF is in block sub cx,bp ; compute length of line mov bx,cx ; save length of line dec cx ; then reduce for CR dec cx ; and LF jcxz notfnd ; jump if line is empty mov di,bp ; address of line in block samln: ; Loop to scan single line for pattern mov si,offset pattrn lodsb ; get byte from [si] to al, increment si cmp exactflg,FLAGSET; /E specified? je sam01 ; jump if yes call xnzscasb ; search for pattern byte, ignoring case jmp short sam02 sam01: repnz scasb ; search for exact match with pattern byte sam02: jnz notfnd ; jump if byte not found cmp cx,dx ; found byte, is line longer than pattern? jb notfnd ; jump if not, not acceptable match push di ; save block address push cx ; and length of line mov cx,dx ; remaining length of pattern jcxz didfnd ; jump if pattern exhausted cmp exactflg,FLAGSET; /E specified? je sam03 ; jump if yes call xzcmpsb ; compare rest of pattern with current source jmp short sam04 sam03: repz cmpsb ; compare for exact match sam04: je didfnd ; jump if found string match pop cx ; no match, restore old count pop di ; and source index jmp samln ; and go continue source scan didfnd: ; here when pattern found pop ax ; discard block address pop ax ; and line length on stack cmp notflg,FLAGSET ; was /V specified? jne negnot ; jump if not jmp nxtscn ; pattern found and /V says list non-matching ; lines, so go search on next line notfnd: ; here when pattern not found on current line cmp notflg,FLAGSET ; was /V specified? jne nxtscn ; jump if not negnot: ; here when (/V AND pattern NOT found) OR ; (NOT /V AND pattern found), i.e. matched cmp cntflg,FLAGSET ; was /C specified? jne nocount ; jump if not inc matches ; had /C, so increment pattern match count jmp nxtscn ; and go search next line nocount: ; here on match when line is to be printed push dx ; save dx (remaining length of pattern) cmp numflg,FLAGSET ; was /N specified? jne nolnnum ; jump if not call writelnnum ; had /N, write line number nolnnum: ; here after possibly writing line number mov dx,bp ; address of line in block mov cx,bx ; length of line call writestr ; go write matching line pop dx ; restore dx jmp nxtscn ; go search next line nofulln: ; here when line split across blocks; ; the input file pointer must be backed ; up to the beginning of the current line mov dx,bx ; length of line pop bx ; file handle or dx,dx ; test line length jz nxtblock ; jump if 0 neg dx ; -(length of line) mov cx,-1 ; (cx,dx) = file offset mov al,$DOS_LSEEK_CURRENT mov ah,$DOS_LSEEK int $DOS ; reposition to beginning of current line jc badread ; abort if lseek failed nxtblock: jmp nxtread ; go for next block badread: ; here on lseek/read failure mov al,RC_READ ; return code call setrc bad01: cmp bx,$STDIN ; reading standard input? jne bad02 ; jump if not jmp nrmexit ; yes, all done bad02: mov ah,$DOS_CLOSE2 ; no, close the file int $DOS mov dx,offset rdderr; error message mov cl,rddlen ; and length jmp dowrite ; write message badfil: ; here on open failure mov dx,offset fnderr; error message mov cl,fndlen ; and length mov al,RC_FILE ; return code call setrc dowrite: ; here to print error message and file name call writeerr call writefil nxtfil: ; here to find next file on command line pop si ; address of last byte examined call skipsp ; flush white space or bx,bx ; end-of-line reached? jnz nrmexit ; yes, all done jmp havfil ; no, go collect file name setrc: ; routine to set return code from al cmp al,rc ; higher than current one? jbe setrc1 ; jump if not mov rc,al ; else save new one setrc1: ret ; return to caller ; routine to build a full filename in fpath (terminated by NUL) ; from wild-carded path in filnam and filename in fname, since ; FINDFIRST/FINDNEXT do not return a complete file spec makefile: push ax ; save registers push cx push si push di mov di,offset fpath ; where full file spec is to go mov si,offset filnam; where wild card spec is cld ; clear direction flag for positive increment push di ; save separator address+1 ; Copy filnam (up to last non-NUL) into fpath, remembering location ; of last separator (:/\) so we can append fname to it. DOS should ; have done this!!! Note that this omission prevents wildcarding ; directory names, since there is no way to determine the directory ; name when only the file name is returned by FINDFIRST/FINDNEXT make01: ; loop copying filnam into fpath lodsb ; source byte to al, increment si cmp al,.NUL ; end-of-string? je make03 ; yes, all done stosb ; no, store byte in al to [di], increment di cmp al,':' ; device separator? je make02 ; jump if separator cmp al,'\' ; path separator? je make02 ; jump if so cmp al,'/' ; alternate path separator? je make02 ; jump if so jmp short make01 ; loop for next character make02: pop ax ; discard old address push di ; remember separator address (+1) jmp short make01 ; loop for more make03: ; here at end-of-string. fpath now has ; copy of filnam (wild-carded spec) pop di ; address of last separator+1 mov si,offset fname make04: ; loop copying fname into fpath after term. lodsb ; byte from [si] to al, increment si stosb ; byte from al to [di], increment di cmp al,.NUL ; end-of-string yet? jne make04 ; loop if more xor cx,cx ; clear count mov si,offset fpath ; address of fpath make05: lodsb ; loop counting characters cmp al,.NUL ; end-of-string yet? je make06 ; yes inc cx ; no, count the character jmp short make05 ; loop for more make06: mov fpalen,cx ; save fpath length pop di ; restore registers saved at entry pop si pop cx pop ax ret ; return to caller errexit: ; here for error exit cmp rc,RC_PARM ; bad parameter? je erruse ; yes, print usage message cmp rc,RC_PATT ; bad je erruse ; yes, print usage message jmp nrmexit ; else just exit erruse: ; here to print usage message mov dx,offset useerr; message address mov cl,uselen ; and length call writedserr nrmexit: ; here to exit to DOS when done mov al,rc ; set return code mov ah,$DOS_EXIT int $DOS ; exit to DOS skipsp: ; routine to skip white space on command line cld ; clear direction flag to increment si xor bx,bx ; clear end-of-line flag returned in bx havesp: ; loop skipping white space lodsb ; get byte from [si] to al, increment si cmp al,' ' ; blank? je havesp ; yes, keep looping cmp al,.HT ; tab? je havesp ; yes, keep looping cmp al,.COMMA ; comma je havesp ; yes, keep looping cmp al,.CR ; end-of-line? jne nocr ; jump if not - hit non-white space character mov bx,ax ; end-of-line hit, set return flag non-zero nocr: dec si ; backup to last white space character ret ; return to caller with bx set to flag clrcnt: ; routine to clear search counts mov byte ptr matches,0 ; clear match count mov byte ptr lineno,0 ; and line number ret writecnt: ; routine to write count push bx ; save file handle cmp bx,$STDIN ; standard input? je nocolon ; jump if yes (no file name output) mov dx,offset colon ; no, follow file name by colon mov cx,2 ; string length call writestr ; write the colon nocolon: mov ax,matches ; count of matches mov di,offset intstr; message call writeint ; write the integer mov dx,offset intstr; message call writestr ; write the message mov dx,offset crlf ; and follow it by mov cx,2 ; a CR LF call writestr pop bx ; restore the file handle ret ; return to caller writelnnum: ; here to write a line number push bx ; save file handle push dx ; and remaining pattern length mov ax,lineno ; line count mov di,offset intstr; message call writeint ; write the integer mov byte ptr [di],']' ; follow it by left square bracket inc cx inc cx ; increment count by 2 mov dx,offset linstr; address of string call writestr ; write [nnnn] string pop dx ; restore pattern length pop bx ; and file handle ret writestr: ; routine to write string at ds:dx,length in cx mov bx,$STDOUT mov ah,$DOS_WRITE2 int $DOS ret writeint: ; routine to format integer in ax to [di] mov bx,10 xor cx,cx ; clear count of bytes written intdiv: inc cx ; increment count of bytes written cmp ax,bx ; remainder < 10? jb intdone ; jump if yes, have only single digit left xor dx,dx ; clear dx (top half of 32-bit numerator) div bx ; (ax,dx)/10 to ax, (ax,dx) mod 10 to dx add dl,'0' ; make into ASCII digit push dx ; save on stack jmp intdiv ; keep collecting digits intdone: add al,'0' ; make into ASCII digit push ax ; save on stack mov bx,cx ; save count of digits intsto: ; loop to pull digits from stack pop ax ; get a digit stosb ; store in target string loop intsto ; loop while cx > 0 mov cx,bx ; count of digits ret ; return to caller writefil: ; routine to write file name and CR LF mov dx,offset fpath ; full filename mov cx,fpalen ; and length call writeerr ; write it mov dx,offset crlf mov cx,2 call writeerr ; write CR LF ret ; return to caller writedserr: ; routine to write error message from ds: call writeerr ret writeerr: ; routine to write error message xor ch,ch mov bx,$STDERR mov ah,$DOS_WRITE2 int $DOS ret lcuc: ; routine to convert al to upper-case cmp al,'a' ; less than 'a' jb ok ; yes, cannot be lower-case cmp al,'z' ; greater than 'z' jg ok ; yes, cannot be lower-case and al,not 20h ; turn off lc bit ok: ret ; return to caller ; ; Begin translated equivalent of REPNZ SCASB ; xnzscasb: push ax ; save ax and push bx ; bx during this loop mov bx, offset xtable xlat byte ptr xtable ; al <- xtable(al) - translated pattern byte mov ah,al ; translated pattern byte loop1: mov al,es:byte ptr [di] ; source byte xlat byte ptr xtable ; translate source byte in al inc di ; point to next byte (like scasb does) cmp ah,al ; source = pattern? loopne loop1 ; decrement cx and loop while no match pop bx ; restore bx pop ax ; and ax ret ; ; End translated equivalent of REPNZ SCASB ; ; ; Begin translated equivalent of REPZ CMPSB ; xzcmpsb: push ax ; save ax and push bx ; bx during this loop mov bx, offset xtable loop2: mov al,byte ptr [si];pattern byte xlat byte ptr xtable ; al <- xtable(al) - translated pattern byte mov ah,al ; translated pattern byte mov al,es:byte ptr [di] ; source byte xlat byte ptr xtable ; translate source byte in al inc si ; point to next byte (like cmpsb does) inc di ; point to next byte (like cmpsb does) cmp ah,al ; source = pattern? loope loop2 ; decrement cx and loop while match pop bx ; restore bx pop ax ; and ax ret ; ; End translated equivalent of REPZ CMPSB ; xtable equ $ ; translation table mapping lower case into upper xbyte=0 rept 97 ; NUL .. "`" --> themselves db xbyte xbyte=xbyte+1 endm xbyte=65 rept 26 ; "a".."z" --> "A".."Z" db xbyte xbyte=xbyte+1 endm xbyte=123 rept 133 ; "["..0FFH --> themselves db xbyte xbyte=xbyte+1 endm patlen dw ; 0332 pattrn db 128 dup (0) ; 0334 fillen dw ; 03b4 filnam db 65 dup (0) ; 03b6 db 9 dup (0) ; file disk transfer area for wild-card expansion even fildta db 21 dup (?) ; reserved for DOS db 0 ; attribute found - 0 means only normal files dw ? ; file's time dw ? ; file's date dw ? ; low word of file size dw ? ; high word of file size fname db 13 dup (?) ; file name (asciz string) ; end of file disk transfer area fpalen dw 0 ; length of fpath (up to before NUL) fpath db 65 dup (0) ; space for expanded file name from dta baddos db "Incorrect DOS version$" ; 00 crlf db .CR,.LF ; 16 numerr db "XFIND: Invalid number of parameters",.CR,.LF ; 18 numlen db numlen-numerr ; 3C synerr db "XFIND: Syntax error",.CR,.LF ; 3D synlen db synlen-synerr ; 51 fnderr db "XFIND: File not found " ; 52 fndlen db fndlen-fnderr ; 67 rdderr db "XFIND: Read error in " ; 68 rddlen db rddlen-rdderr ; 7C prmerr db "XFIND: Invalid Parameter " ; 7D prmlen db prmlen-prmerr ; 95 useerr db "Usage: XFIND [/C] [/E] [/N] [/V] " db '"string"" [[d:][path]filename[.ext] [,]]',.CR,.LF db "/C : match count only",.CR,.LF db "/E : exact match with respect to letter case required",.CR,.LF db "/N : print line numbers of matching lines",.CR,.LF db "/V : invert match - display lines NOT containing pattern" db .CR,.LF uselen db uselen-useerr seplin db .CR,.LF,"---------- " ; 96 seplen db SEPLEN-SEPLIN ; A3 if ($-findc) mod 256 org ($-findc)+256-(($-findc) mod 256) ; Start buffer on 256n ; boundary endif buffer EQU THIS BYTE ; There must be space for MAXBUF dup (?) ; here, plus some more on top for the ; stack. This trick is used instead of ; MAXBUF dup (?) because even with ; initialization to (?), LINK creates a ; .EXE file proportionate in size to ; this value...baahhh!!! findc ends end start